﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Reflection;
using Comm.PublicClass;
using System.Runtime.Serialization;
using Wasion.HHU.Data.Repositories;

namespace WsProtocol.IEC62056MDL
{
    [DataContract]
    public class ProSchemaItem
    {
        private static SchemaDbRepository schemaDbRepository = new SchemaDbRepository();
        private static string ptltable = "T_SchemaItem";
        public static Dictionary<string, ProObAttr> AllItemParlst = new Dictionary<string, ProObAttr>();  //推荐值参数列表
        //public static string CurrSchID = string.Empty;

        public string ID { get; set; }
        public string PID { get; set; }
        public string ObAttrMthID { get; set; }
        public string SNO { get; set; }
        public string SchID { get; set; }
        public string DataValue { get; set; }
        public string RealValue { get; set; }
        public bool CanEdit { get; set; }  //是否可以通过外部字符串修改参数值，默认可以修改

        public List<ProObAttr> ParLst { get; set; } //参数列表,用于保存界面输入值

        public ProSchemaItem()
        {
            ParLst = new List<ProObAttr>();
            CanEdit = true;
        }

        //public static void StartTrans()
        //{
        //    PtlConsts.easyDb.BeginTrans();
        //}

        //public static void RollbackTrans()
        //{
        //    PtlConsts.easyDb.RollbackTrans();
        //}

        //public static void CommitTrans()
        //{
        //    PtlConsts.easyDb.CommitTrans();
        //}
         
        /// <summary>
        /// 获取方案项字典,传入datatable
        /// </summary>
        //public static Dictionary<string, ProSchemaItem> GetSchemaItemLst(DataTable dt,DataTable dtPar)
        //{
        //    Dictionary<string, ProSchemaItem> SchItemlst = new Dictionary<string, ProSchemaItem>();
        //    List<ProSchemaItem> list = TableToList(dt, dtPar);

        //    for (int i = 0; i < list.Count; i++)
        //    {
        //        if (!SchItemlst.ContainsKey(list[i].ObAttrMthID))
        //            SchItemlst.Add(list[i].ObAttrMthID, list[i]);
        //    }
        //    return SchItemlst;

        //}

        /// <summary>
        /// 获取方案项字典,传入datatable
        /// </summary>
        //public static Dictionary<string, ProSchemaItem> GetSchemaItemLst(DataTable dt)
        //{
        //    Dictionary<string, ProSchemaItem> SchItemlst = new Dictionary<string, ProSchemaItem>();
        //    List<ProSchemaItem> list = TableToList(dt, null);

        //    for (int i = 0; i < list.Count; i++)
        //    {
        //        if (!SchItemlst.ContainsKey(list[i].ObAttrMthID))
        //            SchItemlst.Add(list[i].ObAttrMthID, list[i]);
        //    }
        //    return SchItemlst;

        //}


        //private static List<ProSchemaItem> TableToList(DataTable dt,DataTable dtPar)
        //{
        //    List<ProSchemaItem> list = new List<ProSchemaItem>();
        //    ProSchemaItem m = null;
        //    foreach (DataRow dr in dt.Rows)
        //    {
        //        m = GetModelByDataRow(dr, dtPar == null);
        //        if (dtPar != null)
        //           m.ParLst = GetSchemaSonPar(dtPar, m.SchID, m.ObAttrMthID);
                
        //        list.Add(m);
        //    }
        //    return list;
        //}

        /// <summary>
        /// 获取参数值列表
        /// </summary>
        /// <param name="attrid"></param>
        /// <param name="schid"></param>
        /// <returns></returns>
        //private static List<ProObAttr> GetSchemaSonPar(DataTable dt, string schid, string pid)
        //{
        //    List<ProObAttr> parlst = new List<ProObAttr>();
        //    foreach (DataRow dr in dt.Rows)
        //    {
        //        if (dr["SchID"].ToString() == schid && dr["PID"].ToString() == pid)
        //        {
        //            ProObAttr m = ProObAttr.GetModelByDataRow(dr);
        //            parlst.Add(m);
        //        }

        //    }

        //    for (int i = 0; i < parlst.Count; i++)
        //    {
        //        parlst[i].checkState = true;
                
        //        parlst[i].EleLst = GetSchemaSonPar(dt, schid, parlst[i].ID);
        //        parlst[i].ParLst = parlst[i].EleLst;
        //    }
        //    return parlst;
        //}

        /// <summary>
        /// 数据行转对象
        /// </summary>
        /// <param name="dr"></param>
        /// <returns></returns>
        //public static ProSchemaItem GetModelByDataRow(DataRow dr)
        //{
        //    return GetModelByDataRow(dr, true);
        //}


        /// <summary>
        /// 数据行转对象
        /// </summary>
        /// <param name="dr"></param>
        /// <returns></returns>
        //public static ProSchemaItem GetModelByDataRow(DataRow dr, bool withpar)
        //{
        //    ProSchemaItem m = new ProSchemaItem();
        //    m.ID = dr["ID"].ToString();
        //    m.ObAttrMthID = dr["ObAttrMthID"].ToString();
        //    m.PID = dr["PID"].ToString();
        //    m.SNO = dr["SNO"].ToString();
        //    m.SchID = dr["SchID"].ToString();
        //    m.DataValue = dr["DataValue"].ToString();

        //    if (dr.Table.Columns.Contains("RealValue"))  //shaunwang  2019-4-15 参数项的真实设置值
        //        m.RealValue = dr["RealValue"].ToString();

        //    if (withpar)
        //        m.ParLst = GetSchemaAttrPar(m.ID);
        //    return m;
        //}
       

        /// <summary>
        /// 根据方案ID获取方案项
        /// </summary>
        /// <param name="schid"></param>
        /// <param name="IsVisible"></param>
        /// <returns></returns>
        //public static List<ProSchemaItem> GetSchItemBySch(string schid)
        //{            
        //    List<ProSchemaItem> list = new List<ProSchemaItem>();
        //    if (string.IsNullOrEmpty(schid)) 
        //        return list;

        //    AllItemParlst = GetAllItemParlst(schid);//不能放到TableToList后面，取出此方案下存在于第三个表中的所有参数列表

        //    PtlConsts.easyDb.Clear();
        //    PtlConsts.easyDb.TableName = ptltable;
        //    PtlConsts.easyDb.SetOrder("SchID,PID,SNO");
        //    PtlConsts.easyDb.SetWhereParameter(true, "SchID", "=", schid, EasyDataType.String);
        //    list = TableToList(PtlConsts.easyDb.Select(),null);

            
        //    return list;
        //}


        /// <summary>
        /// 获取方案项数据集
        /// </summary>
        /// <param name="schid"></param>
        /// <returns></returns>
        //public static DataTable GetItemDataTableBySch(string schid)
        //{
        //    PtlConsts.easyDb.Clear();
        //    PtlConsts.easyDb.TableName = ptltable;
        //    if (!string.IsNullOrEmpty(schid))
        //        PtlConsts.easyDb.SetWhereParameter(true, "SchID", "=", schid, EasyDataType.String);
        //    DataTable dtSchema = PtlConsts.easyDb.Select();
        //    dtSchema.TableName = ptltable;
        //    return dtSchema;
        //}

        /// <summary>
        /// 用于将选中的对象保存到方案项表里
        /// </summary>
        /// <param name="insertFlag"></param>
        /// <param name="schema"></param>
        /// <param name="obAttr"></param>
        /// <param name="IsInputValue"></param>
        /// <returns></returns>
        //public static int SaveSchItem(bool insertFlag, ProSchema schema, ProObAttr obAttr, bool IsInputValue, ref string errinfo)
        //{
        //    int rs = 0;
        //    ProSchemaItem aitem = new ProSchemaItem();
        //    aitem.SchID = schema.ID;
        //    aitem.ObAttrMthID = obAttr.ID;
        //    PtlConsts.easyDb.Clear();
        //    PtlConsts.easyDb.TableName = ptltable;
        //    PtlConsts.easyDb.SetFieldValue("ObAttrMthID", aitem.ObAttrMthID, EasyDataType.String);
        //    if (IsInputValue) //是否用界面输入值保存，有些情况需要保存抄读数据
        //    {
        //        //增加判断当前输入值为空但是其父节点的输入值不为空的情况  shaunwang 2018-4-8
        //        if ((obAttr.IsVisible)
        //            && (string.IsNullOrEmpty(obAttr.OBIS))
        //            && (obAttr.AttrMth == AttrType.元素) 
        //            && (obAttr.ParentAttr != null)
        //            && (obAttr.ParentAttr.AttrMth == AttrType.元素))
        //        {
        //            if (string.IsNullOrEmpty(obAttr.inputValue) 
        //                && !string.IsNullOrEmpty(obAttr.ParentAttr.inputValue)
        //                && (obAttr.ParentAttr.ParForm == TFormType.无 || obAttr.ParentAttr.ParForm == TFormType.只读))
        //            {
        //                errinfo = clsLan.GetLan("参数值为空但其父节点") + "[" + obAttr.ParentAttr.OBIS + "-" + obAttr.ParentAttr.ProName + "]" + clsLan.GetLan("参数值不为空");
        //                return -1;
        //            }
        //        }                
        //        aitem.DataValue = obAttr.inputValue;
        //    }
        //    else
        //    {
        //        aitem.DataValue = obAttr.readValue;
        //    }
        //    PtlConsts.easyDb.SetFieldValue("DataValue", aitem.DataValue, EasyDataType.String);

        //    //保存真实值  shaunwang 2019-4-15
        //    if (!string.IsNullOrEmpty(obAttr.Display))
        //        PtlConsts.easyDb.SetFieldValue("RealValue", obAttr.DisplayToFrame(aitem.DataValue), EasyDataType.String);


        //    PtlConsts.easyDb.SetFieldValue("SNO", obAttr.Seq.ToString(), EasyDataType.String);
        //    aitem.SNO = obAttr.Seq.ToString();

        //    //父ID
        //    if (obAttr.ParentAttr != null)
        //    {
        //        PtlConsts.easyDb.SetFieldValue("PID", obAttr.ParentAttr.ID, EasyDataType.String);
        //        aitem.PID = obAttr.ParentAttr.ID;
        //    }
        //    else
        //    {
        //        PtlConsts.easyDb.SetFieldValue("PID", "", EasyDataType.String);
        //        aitem.PID = "";
        //    }
        //    PtlConsts.easyDb.SetFieldValue("SchID", schema.ID, EasyDataType.String);

            
        //    if (insertFlag)
        //    {
        //        aitem.ID = Guid.NewGuid().ToString();
        //        PtlConsts.easyDb.SetFieldValue("ID", aitem.ID, EasyDataType.String);
        //        rs = PtlConsts.easyDb.Insert(ref errinfo);
        //        if (rs > 0)
        //        {
        //            if (!schema.SchemaItemlst.ContainsKey(aitem.ObAttrMthID))
        //                schema.SchemaItemlst.Add(aitem.ObAttrMthID, aitem);
        //        }
        //    }
        //    else
        //    {
        //        PtlConsts.easyDb.SetWhereParameter(true, "ID", "=", aitem.ID, EasyDataType.String);               
        //        rs = PtlConsts.easyDb.Update(ref errinfo);                
        //    }

        //    //开始保存方案项的参数 shaunwang 2017-8-10
        //    List<ProObAttr> ParLst = obAttr.ParLst;
        //    if (!IsInputValue)
        //        ParLst = obAttr.ReadParLst;

        //    if (rs > 0 && ParLst != null && ParLst.Count > 0)
        //    {
        //        aitem.ParLst = ParLst;
        //        for (int i = 0; i < ParLst.Count; i++)
        //        {
        //            rs = SaveSchemaAttrPar(schema.ID, ParLst[i],true, aitem.ID, IsInputValue, ref errinfo);//obAttr.ParLst[i]
        //            if (rs <= 0)
        //                break;
        //        }
        //    }
        //    if (rs <= 0)
        //        rs = -1;

        //    return rs;
        //}

        /// <summary>
        /// 批量保存方案项
        /// </summary>
        /// <param name="insertFlag"></param>
        /// <param name="SchID"></param>
        /// <param name="obAttrLst"></param>
        /// <param name="IsInputValue"></param>
        /// <returns></returns>
        //public static int SaveSchItem(bool insertFlag, ProSchema schema, List<ProObAttr> obAttrLst, bool IsInputValue, ref string errinfo)
        //{
        //    int rs = 1;
        //    //PtlConsts.easyDb.BeginTrans();
        //    try
        //    {
        //        for (int i = 0; i < obAttrLst.Count; i++)
        //        {
        //            Application.DoEvents();
        //            rs = SaveSchItem(insertFlag, schema, obAttrLst[i], IsInputValue, ref errinfo);
        //            if (rs <= 0)
        //            {
        //                errinfo = clsLan.GetLan("保存方案项") + "[" + obAttrLst[i].ProName + "]" + clsLan.GetLan("失败:") + errinfo;
        //                //PtlConsts.easyDb.RollbackTrans();
        //                break;
        //            }
        //        }
        //        //PtlConsts.easyDb.CommitTrans();
        //    }
        //    catch (Exception ex)
        //    {
        //        errinfo = ex.Message;
        //        //PtlConsts.easyDb.RollbackTrans();
        //    }
        //    return rs;
            
            
        //}

        /// <summary>
        /// 用于将从文件导入的方案项保存到数据库里
        /// </summary>
        /// <param name="insertFlag">true时是插入增加,false更新</param>
        /// <returns></returns>
        //public int SaveSchItem(bool insertFlag, ref string errinfo)
        //{
        //    int rs = 0;
        //    PtlConsts.easyDb.Clear();
        //    PtlConsts.easyDb.TableName = ptltable;
        //    PtlConsts.easyDb.SetFieldValue("SchID", SchID, EasyDataType.String);
        //    PtlConsts.easyDb.SetFieldValue("DataValue", DataValue, EasyDataType.String);
        //    PtlConsts.easyDb.SetFieldValue("SNO", SNO, EasyDataType.String);

        //    //父ID
        //    PtlConsts.easyDb.SetFieldValue("PID", PID, EasyDataType.String);
        //    PtlConsts.easyDb.SetFieldValue("ObAttrMthID", ObAttrMthID, EasyDataType.String);
        //    if (insertFlag)
        //    {
        //        if (string.IsNullOrEmpty(ID))
        //            ID = Guid.NewGuid().ToString();
        //        PtlConsts.easyDb.SetFieldValue("ID", ID, EasyDataType.String);
        //       // PtlConsts.easyDb.SetTableIndex("SchID,AttrOAD,SerialNO");
        //        rs = PtlConsts.easyDb.Insert(ref errinfo);
               
        //        if (rs <= 0)
        //            rs = -1;
        //    }
        //    else
        //    {
        //        PtlConsts.easyDb.SetWhereParameter(true, "ID", "=", ID, EasyDataType.Number);
        //        rs = PtlConsts.easyDb.Update(ref errinfo);
        //    }
        //    return rs;
        //}


        //改为静态方法  shaunwang 2017-2-10
        //public static int DeleteItemBySchID(string schid, ref string errinfo)
        //{
        //    if (string.IsNullOrEmpty(schid)) return 1;
        //    try
        //    {
        //        //删除方案项
        //        PtlConsts.easyDb.Clear();
        //        PtlConsts.easyDb.TableName = ptltable;
        //        PtlConsts.easyDb.SetWhereParameter(true, "SchID", "=", schid, EasyDataType.String);
        //        int rs = PtlConsts.easyDb.Delete(ref errinfo);

        //        //删除方案包含的参数
        //        if (rs > 0)
        //            rs = DeleteSchemaAttrPar(schid, ref errinfo);
                
        //        return rs;
        //    }
        //    catch(Exception ex)
        //    {
        //        errinfo = ex.Message;
        //        return -1;
        //    }
        //}

        /// <summary>
        /// 从方案项列表中查找,并取得方案项的值
        /// </summary>
        /// <param name="inAttr"></param>
        /// <param name="itemlst"></param>
        /// <returns></returns>
        public static bool FindItemByObAttr(ProObAttr inAttr, Dictionary<string, ProSchemaItem> itemlst)
        {
            bool rs = false;
            inAttr.ParLst.Clear();  //hxh 先清一下参数列表,避免不同方案切换时出现值还保留着上一个方案的值
            if (inAttr == null || itemlst == null || itemlst.Count == 0)
                return rs;

            if (itemlst.ContainsKey(inAttr.ID))
            {
                ProSchemaItem aSchItem = itemlst[inAttr.ID];
                rs = true;

                inAttr.inputValue = aSchItem.DataValue;
                //shaunwang 2019-4-16  用真实值刷新一下显示值，防止不同语言的方案交叉使用
                if (!string.IsNullOrEmpty(inAttr.Display) && !string.IsNullOrEmpty(aSchItem.RealValue))
                    inAttr.inputValue = inAttr.FrameToDisplay(aSchItem.RealValue);

                ////针对时段表这样的参数，按;拆分，分到子节点去
                ////inAttr.SplitValue();            
                
                //inAttr.ParLst = copyItemParLst(inAttr, aSchItem);
                copyItemParLst(inAttr, aSchItem);
                for (int p = 0; p < inAttr.ParLst.Count; p++)
                {
                    inAttr.ParLst[p].ParentAttr = inAttr;
                }
            }

            return rs;
        }
        public static void copyItemParLst(ProObAttr inAttr, ProSchemaItem aSchItem) {          
            for (int p = 0; p < aSchItem.ParLst.Count; p++)
            {
                ProObAttr parroot = aSchItem.ParLst[p]; 
                if (string.IsNullOrEmpty(parroot.ProName)) //一般是没找到此参数项在属性表里对应的项而产生,原来生成的方案但因服务器上相关的协议项可能删除重新添加
                {                    

                    ProObAttr obAttr = p >= inAttr.EleLst.Count ? inAttr.EleLst[inAttr.EleLst.Count - 1] : inAttr.EleLst[p];

                    string inputvalue = parroot.inputValue;
                    //复制属性
                    PropertyInfo[] fromFields = typeof(ProObAttr).GetProperties();
                    try
                    {
                        foreach (PropertyInfo fromField in fromFields)
                        {
                            if (ProObAttr.FieldLst.IndexOf(fromField.Name) >= 0)
                                continue;
                            fromField.SetValue(parroot,fromField.GetValue(obAttr, null),null);
                        }                        
                    }
                    catch (Exception ex)
                    { }                                       
                    parroot.inputValue = inputvalue;

                    //shaunwang 2019-4-16  用真实值刷新一下显示值，防止不同语言的方案交叉使用
                    if (!string.IsNullOrEmpty(parroot.Display) && !string.IsNullOrEmpty(obAttr.RealValue))
                        parroot.inputValue = parroot.FrameToDisplay(obAttr.RealValue);


                    copyItemParEleLst(obAttr, parroot);                   
                }
            }
            inAttr.ParLst = aSchItem.ParLst;
        }
        private static void copyItemParEleLst(ProObAttr inObAttr, ProObAttr ItemObAttr)
        {
            if (ItemObAttr.EleLst.Count == 0)                        
                return;
         
            for (int p = 0; p < ItemObAttr.EleLst.Count; p++)
            {
                ProObAttr parroot = ItemObAttr.EleLst[p];
                if (string.IsNullOrEmpty(parroot.ProName))
                {
                    ProObAttr obAttr = p >= inObAttr.EleLst.Count ? inObAttr.EleLst[inObAttr.EleLst.Count - 1] : inObAttr.EleLst[p];
                    string inputvalue = parroot.inputValue;
                    //复制属性
                    PropertyInfo[] fromFields = typeof(ProObAttr).GetProperties();
                    try
                    {
                        foreach (PropertyInfo fromField in fromFields)
                        {
                            if (ProObAttr.FieldLst.IndexOf(fromField.Name) >= 0)
                                continue;
                            fromField.SetValue(parroot, fromField.GetValue(obAttr, null), null);
                        }                       
                    }
                    catch (Exception ex)
                    { }     
                    parroot.inputValue = inputvalue;

                    //shaunwang 2019-4-16  用真实值刷新一下显示值，防止不同语言的方案交叉使用
                    if (!string.IsNullOrEmpty(parroot.Display) && !string.IsNullOrEmpty(obAttr.RealValue))
                        parroot.inputValue = parroot.FrameToDisplay(obAttr.RealValue);

                    copyItemParEleLst(obAttr, parroot);                   
                }               
            }
        }

        //public static List<ProObAttr> copyItemParLst(ProObAttr inAttr, ProSchemaItem aSchItem)
        //{
        //    List<ProObAttr> aparlst = new List<ProObAttr>();
        //    for (int p = 0; p < aSchItem.ParLst.Count; p++)
        //    {
        //        ProObAttr parroot = aSchItem.ParLst[p].Copy();
        //        aparlst.Add(parroot);

        //        if (string.IsNullOrEmpty(parroot.ProName)) //一般是没找到此参数项在属性表里对应的项而产生,原来生成的方案但因服务器上相关的协议项可能删除重新添加
        //        {
        //            ProObAttr obAttr = p >= inAttr.EleLst.Count ? inAttr.EleLst[inAttr.EleLst.Count-1] : inAttr.EleLst[p];

        //            ProObAttr tmpAttr = obAttr.Copy();
        //            tmpAttr.inputValue = parroot.inputValue;
        //            tmpAttr.DataType = parroot.DataType;
        //            tmpAttr.DataTypeDIY = parroot.DataTypeDIY;
        //            tmpAttr.Scaler = parroot.Scaler;
        //            tmpAttr.EleNodetype = parroot.EleNodetype;

        //            parroot = tmpAttr;
                    
        //            copyItemParEleLst(parroot, obAttr, aSchItem.ParLst[p]);
        //           // aSchItem.ParLst[p] = obAttr;
        //        }
        //    }
        //    //inAttr.ParLst = aSchItem.ParLst;
        //    return aparlst;
        //}

        //private static void copyItemParEleLst(ProObAttr inParObAttr, ProObAttr inObAttr, ProObAttr ItemObAttr)
        //{
        //    if (ItemObAttr.EleLst.Count == 0)
        //    {
        //        //ItemObAttr = inObAttr;
        //        return;
        //    }
            
        //    for (int p = 0; p < ItemObAttr.EleLst.Count; p++)
        //    {
        //        ProObAttr parroot = ItemObAttr.EleLst[p].Copy();
        //        if (string.IsNullOrEmpty(parroot.ProName))
        //        {
        //            ProObAttr obAttr = p >= inObAttr.EleLst.Count ? inObAttr.EleLst[inObAttr.EleLst.Count - 1]: inObAttr.EleLst[p];
        //            ProObAttr tmpAttr = obAttr.Copy();

        //            tmpAttr.inputValue = parroot.inputValue;
        //            tmpAttr.DataType = parroot.DataType;
        //            tmpAttr.DataTypeDIY = parroot.DataTypeDIY;
        //            tmpAttr.Scaler = parroot.Scaler;
        //            tmpAttr.EleNodetype = parroot.EleNodetype;
        //            parroot = tmpAttr;


        //            copyItemParEleLst(parroot, obAttr, ItemObAttr.EleLst[p]);
        //           // ItemObAttr.EleLst[p] = obAttr;
        //        }
        //        inParObAttr.EleLst.Add(parroot);
        //    }            
        //    //inObAttr = ItemObAttr;
        //}
        #region 方案项参数相关方法
       

        //public static Dictionary<string, ProObAttr> GetAllItemParlst(string schid) {

        //    PtlConsts.easyDb.Clear();
        //    PtlConsts.easyDb.SetSQLText("select * from T_SchemaItemPar a left join V_obattrmth b on (a.ObAttrMthID=b.id) where a.SchID='" + schid + "' order by SNO");
        //    return ProObAttr.TableToList(PtlConsts.easyDb.Select());
        //}

        /// <summary>
        /// 获取某个参数方案下某个方案项的参数列表
        /// </summary>
        /// <param name="attrid"></param>
        /// <param name="schid"></param>
        /// <returns></returns>
        public static List<ProObAttr> GetSchemaAttrPar(string AttrID)
        {
            List<ProObAttr> parlst = new List<ProObAttr>();
            if (AllItemParlst == null || AllItemParlst.Count == 0)
                return parlst;
            
            //foreach (ProObAttr attr in AllItemParlst)
            foreach (string id in AllItemParlst.Keys)
            {
                ProObAttr attr = AllItemParlst[id];
                if (attr.PID == AttrID)
                {
                    parlst.Add(attr);
                    attr.EleLst = GetSchemaSonPar(attr.ID);
                   
                }
            }
            return parlst;          
        }


        private static List<ProObAttr> GetSchemaSonPar(string pid)
        {
            //PtlConsts.easyDb.Clear();
            //PtlConsts.easyDb.SetSQLText("select * from T_SchemaItemPar a left join V_obattrmth b on (a.ObAttrMthID=b.id) where a.SchID='" + schid + "' and a.PID='" + pid + "' order by SNO");
            //List<ProObAttr> parlst = ProObAttr.TableToList(PtlConsts.easyDb.Select());
            //for (int i = 0; i < parlst.Count; i++)
            //{
            //   // parlst[i].checkState = true;
            //    parlst[i].EleLst = GetSchemaSonPar(schid, parlst[i].ID);
            //}


            List<ProObAttr> parlst = new List<ProObAttr>();
            //foreach (ProObAttr attr in AllItemParlst)
            foreach (string id in AllItemParlst.Keys)
            {
                ProObAttr attr = AllItemParlst[id];
                if (attr.PID == pid)
                {
                    parlst.Add(attr);
                    attr.EleLst = GetSchemaSonPar(attr.ID);
                    attr.ParLst = attr.EleLst;
                }
            }          
            return parlst; 
        }

        /// <summary>
        /// 获取参数列表
        /// </summary>
        /// <param name="schid">方案ID</param>
        /// <param name="pid">父对象唯一编码</param>
        /// <param name="parobattr">父对象</param>
        /// <param name="dt"></param>
        /// <returns></returns>
        //public static List<ProObAttr> GetSchemaSonPar(string schid, string pid, ProObAttr parobattr, DataTable dt)
        //{
        //    List<ProObAttr> parlst = new List<ProObAttr>();
        //    if (string.IsNullOrEmpty(pid) || dt == null)
        //        return parlst;
        //    foreach (DataRow dr in dt.Rows)
        //    {
        //        if (dr["BackUP1"].ToString() == schid && dr["PID"].ToString() == pid)
        //        {
        //            ProObAttr aObAttr =ProObAttr.GetModelByDataRow(dr);
        //            aObAttr.checkState = aObAttr.IsVisible ? true : false;
        //            aObAttr.CanEdit = dr["CanEdit"].ToString() == "true";
        //            aObAttr.ParentAttr = parobattr;
        //            parlst.Add(aObAttr);
        //        }
        //    }

        //    for (int i = 0; i < parlst.Count; i++)
        //    {
        //        parlst[i].EleLst = GetSchemaSonPar(schid, parlst[i].ID, parlst[i], dt);
        //    }
        //    return parlst;
        //}

        /// <summary>
        /// 获取某个方案下所有方案项的参数
        /// </summary>
        /// <param name="schid"></param>
        /// <returns></returns>
        //public static DataTable GetParDataTablePar(string schid)
        //{
        //    PtlConsts.easyDb.Clear();
        //    PtlConsts.easyDb.SetSQLText("select * from T_SchemaItemPar a left join V_obattrmth b on (a.ObAttrMthID=b.id) where a.SchID='" + schid + "' order by SNO");
        //    DataTable dtSchItemPar = PtlConsts.easyDb.Select();
        //    dtSchItemPar.TableName = "T_SchemaItemPar";
        //    return dtSchItemPar;
        //}

        /// <summary>
        /// 清除某个方案下的所有方案项参数
        /// </summary>
        /// <param name="schid"></param>
        /// <param name="errinfo"></param>
        /// <returns></returns>
        //public static int DeleteSchemaAttrPar(string schid, ref string errinfo)
        //{
        //    PtlConsts.easyDb.Clear();
        //    PtlConsts.easyDb.TableName = "T_SchemaItemPar";
        //    PtlConsts.easyDb.SetWhereParameter(true, "SchID", "=", schid, EasyDataType.String);
        //    int rs = PtlConsts.easyDb.Delete(ref errinfo);
        //    return rs;
        //}


        /// <summary>        /// 
        /// 保存某个参数方案下的参数列表        
        /// hxh 2017-9-12 增加了个PID参数，因为有些节点是复制父节点下第一个节点而生成的新节点，有ParentAttr但保存入库之后实际的PID是变化的，如显示     
        /// <param name="schid"></param>
        /// <param name="PAttr"></param>
        /// <param name="NewParID">是否重新生成参数项ID，导入方案的情况下不能重新生成</param>
        /// <param name="PID"></param>
        /// <param name="IsInputValue"></param>
        /// <param name="errinfo"></param>
        /// <returns></returns>
        //public static int SaveSchemaAttrPar(string schid, ProObAttr PAttr, bool NewParID, string PID, bool IsInputValue, ref string errinfo)
        //{
        //    PtlConsts.easyDb.Clear();
        //    PtlConsts.easyDb.TableName = "T_SchemaItemPar";
        //    PtlConsts.easyDb.SetFieldValue("SchID", schid, EasyDataType.String);
        //    string ParID = PAttr.ID;
        //    if (NewParID || string.IsNullOrEmpty(ParID))
        //        ParID = Guid.NewGuid().ToString();
        //    PtlConsts.easyDb.SetFieldValue("ID", ParID, EasyDataType.String);
        //    if (string.IsNullOrEmpty(PID))
        //        PID = PAttr.ID;

        //    PtlConsts.easyDb.SetFieldValue("PID", PID, EasyDataType.String);
        //    PtlConsts.easyDb.SetFieldValue("ObAttrMthID", PAttr.ID, EasyDataType.String);

        //    string seq = PubFunc62056.GetNewId("T_SchemaItemPar", "SNO");
        //    PtlConsts.easyDb.SetFieldValue("SNO", seq, EasyDataType.Number);
        //    PtlConsts.easyDb.SetFieldValue("Scaler", PAttr.Scaler, EasyDataType.String);
        //    PtlConsts.easyDb.SetFieldValue("DataType", PAttr.DataType, EasyDataType.String);
        //    PtlConsts.easyDb.SetFieldValue("DataTypeDIY", PAttr.DataTypeDIY, EasyDataType.String);
        //    PtlConsts.easyDb.SetFieldValue("EleNodetype", ((int)PAttr.EleNodetype).ToString(), EasyDataType.Number);
        //    PtlConsts.easyDb.SetFieldValue("SpeParForm", PAttr.SpeParForm, EasyDataType.String);

        //    if (IsInputValue && !string.IsNullOrEmpty(PAttr.inputValue))
        //    {
        //        PAttr.DefValue = PAttr.inputValue;
        //    }
        //    else 
        //        if (!IsInputValue && !string.IsNullOrEmpty(PAttr.readValue))
        //        {
        //            PAttr.DefValue = PAttr.readValue;
        //        }
        //    PtlConsts.easyDb.SetFieldValue("DefValue", PAttr.DefValue, EasyDataType.String);


        //    //保存真实值  shaunwang 2019-4-15
        //    if (!string.IsNullOrEmpty(PAttr.Display))
        //        PAttr.RealValue = PAttr.DisplayToFrame(PAttr.DefValue);

        //    int rs = PtlConsts.easyDb.Insert(ref errinfo);
        //    if (rs <= 0)
        //        return rs;

        //    if(PAttr.ParLst.Count==0)
        //        for (int i = 0; i < PAttr.EleLst.Count; i++)
        //        {
        //            Application.DoEvents();
        //            rs = SaveSchemaAttrPar(schid, PAttr.EleLst[i],NewParID, ParID, IsInputValue, ref errinfo);
        //            if (rs <= 0)
        //                return rs;
        //        }
        //    else
        //        for (int i = 0; i < PAttr.ParLst.Count; i++)
        //        {
        //            Application.DoEvents();
        //            rs = SaveSchemaAttrPar(schid, PAttr.ParLst[i],NewParID, ParID, IsInputValue, ref errinfo);
        //            if (rs <= 0)
        //                return rs;
        //        }

        //    return rs;
        //}
        #endregion

       

       

    }
}
